Towards a Lock-based Semantics for Java STM

As memory transactions have been proposed as a language-level replacement for locks, there is growing consensus that software transactional memory (STM) implementations need to provide semantic guarantees at least as strong as locks. In this paper, we investigate the implications of lock-based semantics for transactions. We categorize safety properties imposed by these semantics into two sets: (1) those that maintain proper ordering and (2) those that prevent values from appearing out of thin air. As part of this, we define publication safety, the dual of privatization safety [16, 25, 23] and a property most existing STMs violate. For Java, we argue that an STM must respect all these properties to properly adhere to its memory model and maintain safety and security guarantees. Moreover, we also show that a weakly atomic, in-place update STM [3, 1] cannot provide these guarantees. For C++, we reason that only a subset of these properties need to be observed as the behavior of incorrectly synchronized programs can be left undefined. However, we show that violations of others can still lead to nonintuitive behavior in the presence of seemingly benign races and requires STM to impose surprising restrictions on what programmers and compilers are allow to do. Many in the community have proposed that a single global lock semantics [16, 7], where transaction semantics are mapped to those of regions protected by a single global lock, provide the most intuitive model for programmers. In this paper, we present a weakly atomic Java STM implementation that provides these semantics, obeys all the above safety properties, and permits concurrent execution. We also propose and implement two alternative semantics that loosen single lock requirements while still providing privatization safety, publication safety, and other properties. We compare our new implementations to previous ones, including a strongly atomic STM. [23]